package com.reportgear.report.model.script;

// $ANTLR 3.2 Sep 23, 2009 12:02:23 D:\\antlr\\ConditionExpr.g 2010-01-16 23:10:56

import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.CharStream;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.Lexer;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;

public class ConditionExprLexer extends Lexer {
    public static final int LT=14;
    public static final int T__29=29;
    public static final int T__28=28;
    public static final int NumberLiteral=20;
    public static final int AND_1=6;
    public static final int AND_2=8;
    public static final int LTEQ=15;
    public static final int GTEQ=13;
    public static final int AND=4;
    public static final int EOF=-1;
    public static final int HexDigit=26;
    public static final int BELONGTO=18;
    public static final int StringLiteral=21;
    public static final int NOTLIKE=17;
    public static final int WS=27;
    public static final int NEQ=11;
    public static final int UnicodeEscape=23;
    public static final int OR=5;
    public static final int GT=12;
    public static final int EQ=10;
    public static final int OR_1=7;
    public static final int OR_2=9;
    public static final int OctalEscape=24;
    public static final int EscapeSequence=25;
    public static final int BooleanLiteral=19;
    public static final int LIKE=16;
    public static final int NumberListLiteral=22;

    // delegates
    // delegators

    public ConditionExprLexer() {;} 
    public ConditionExprLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public ConditionExprLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "D:\\antlr\\ConditionExpr.g"; }

    // $ANTLR start "AND"
    public final void mAND() throws RecognitionException {
        try {
            int _type = AND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:3:5: ( 'and' )
            // D:\\antlr\\ConditionExpr.g:3:7: 'and'
            {
            match("and"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:4:4: ( 'or' )
            // D:\\antlr\\ConditionExpr.g:4:6: 'or'
            {
            match("or"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "AND_1"
    public final void mAND_1() throws RecognitionException {
        try {
            int _type = AND_1;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:5:7: ( '*' )
            // D:\\antlr\\ConditionExpr.g:5:9: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND_1"

    // $ANTLR start "OR_1"
    public final void mOR_1() throws RecognitionException {
        try {
            int _type = OR_1;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:6:6: ( '+' )
            // D:\\antlr\\ConditionExpr.g:6:8: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR_1"

    // $ANTLR start "AND_2"
    public final void mAND_2() throws RecognitionException {
        try {
            int _type = AND_2;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:7:7: ( '&&' )
            // D:\\antlr\\ConditionExpr.g:7:9: '&&'
            {
            match("&&"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AND_2"

    // $ANTLR start "OR_2"
    public final void mOR_2() throws RecognitionException {
        try {
            int _type = OR_2;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:8:6: ( '||' )
            // D:\\antlr\\ConditionExpr.g:8:8: '||'
            {
            match("||"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OR_2"

    // $ANTLR start "EQ"
    public final void mEQ() throws RecognitionException {
        try {
            int _type = EQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:9:4: ( '==' )
            // D:\\antlr\\ConditionExpr.g:9:6: '=='
            {
            match("=="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EQ"

    // $ANTLR start "NEQ"
    public final void mNEQ() throws RecognitionException {
        try {
            int _type = NEQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:10:5: ( '<>' )
            // D:\\antlr\\ConditionExpr.g:10:7: '<>'
            {
            match("<>"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NEQ"

    // $ANTLR start "GT"
    public final void mGT() throws RecognitionException {
        try {
            int _type = GT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:11:4: ( '>' )
            // D:\\antlr\\ConditionExpr.g:11:6: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GT"

    // $ANTLR start "GTEQ"
    public final void mGTEQ() throws RecognitionException {
        try {
            int _type = GTEQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:12:6: ( '>=' )
            // D:\\antlr\\ConditionExpr.g:12:8: '>='
            {
            match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GTEQ"

    // $ANTLR start "LT"
    public final void mLT() throws RecognitionException {
        try {
            int _type = LT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:13:4: ( '<' )
            // D:\\antlr\\ConditionExpr.g:13:6: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LT"

    // $ANTLR start "LTEQ"
    public final void mLTEQ() throws RecognitionException {
        try {
            int _type = LTEQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:14:6: ( '<=' )
            // D:\\antlr\\ConditionExpr.g:14:8: '<='
            {
            match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LTEQ"

    // $ANTLR start "LIKE"
    public final void mLIKE() throws RecognitionException {
        try {
            int _type = LIKE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:15:6: ( 'like' )
            // D:\\antlr\\ConditionExpr.g:15:8: 'like'
            {
            match("like"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LIKE"

    // $ANTLR start "NOTLIKE"
    public final void mNOTLIKE() throws RecognitionException {
        try {
            int _type = NOTLIKE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:16:9: ( 'not like' )
            // D:\\antlr\\ConditionExpr.g:16:11: 'not like'
            {
            match("not like"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NOTLIKE"

    // $ANTLR start "BELONGTO"
    public final void mBELONGTO() throws RecognitionException {
        try {
            int _type = BELONGTO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:17:10: ( 'belong to' )
            // D:\\antlr\\ConditionExpr.g:17:12: 'belong to'
            {
            match("belong to"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BELONGTO"

    // $ANTLR start "T__28"
    public final void mT__28() throws RecognitionException {
        try {
            int _type = T__28;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:18:7: ( '(' )
            // D:\\antlr\\ConditionExpr.g:18:9: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__28"

    // $ANTLR start "T__29"
    public final void mT__29() throws RecognitionException {
        try {
            int _type = T__29;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:19:7: ( ')' )
            // D:\\antlr\\ConditionExpr.g:19:9: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__29"

    // $ANTLR start "EscapeSequence"
    public final void mEscapeSequence() throws RecognitionException {
        try {
            // D:\\antlr\\ConditionExpr.g:166:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UnicodeEscape | OctalEscape )
            int alt1=3;
            int LA1_0 = input.LA(1);

            if ( (LA1_0=='\\') ) {
                switch ( input.LA(2) ) {
                case '\"':
                case '\'':
                case '\\':
                case 'b':
                case 'f':
                case 'n':
                case 'r':
                case 't':
                    {
                    alt1=1;
                    }
                    break;
                case 'u':
                    {
                    alt1=2;
                    }
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                    {
                    alt1=3;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 1, 1, input);

                    throw nvae;
                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:166:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
                    {
                    match('\\'); 
                    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:167:9: UnicodeEscape
                    {
                    mUnicodeEscape(); 

                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:168:9: OctalEscape
                    {
                    mOctalEscape(); 

                    }
                    break;

            }
        }
        finally {
        }
    }
    // $ANTLR end "EscapeSequence"

    // $ANTLR start "HexDigit"
    public final void mHexDigit() throws RecognitionException {
        try {
            // D:\\antlr\\ConditionExpr.g:172:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // D:\\antlr\\ConditionExpr.g:172:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
            {
            if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "HexDigit"

    // $ANTLR start "UnicodeEscape"
    public final void mUnicodeEscape() throws RecognitionException {
        try {
            // D:\\antlr\\ConditionExpr.g:176:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )
            // D:\\antlr\\ConditionExpr.g:176:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit
            {
            match('\\'); 
            match('u'); 
            mHexDigit(); 
            mHexDigit(); 
            mHexDigit(); 
            mHexDigit(); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "UnicodeEscape"

    // $ANTLR start "OctalEscape"
    public final void mOctalEscape() throws RecognitionException {
        try {
            // D:\\antlr\\ConditionExpr.g:182:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
            int alt2=3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0=='\\') ) {
                int LA2_1 = input.LA(2);

                if ( ((LA2_1>='0' && LA2_1<='3')) ) {
                    int LA2_2 = input.LA(3);

                    if ( ((LA2_2>='0' && LA2_2<='7')) ) {
                        int LA2_5 = input.LA(4);

                        if ( ((LA2_5>='0' && LA2_5<='7')) ) {
                            alt2=1;
                        }
                        else {
                            alt2=2;}
                    }
                    else {
                        alt2=3;}
                }
                else if ( ((LA2_1>='4' && LA2_1<='7')) ) {
                    int LA2_3 = input.LA(3);

                    if ( ((LA2_3>='0' && LA2_3<='7')) ) {
                        alt2=2;
                    }
                    else {
                        alt2=3;}
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:182:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 
                    // D:\\antlr\\ConditionExpr.g:182:14: ( '0' .. '3' )
                    // D:\\antlr\\ConditionExpr.g:182:15: '0' .. '3'
                    {
                    matchRange('0','3'); 

                    }

                    // D:\\antlr\\ConditionExpr.g:182:25: ( '0' .. '7' )
                    // D:\\antlr\\ConditionExpr.g:182:26: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }

                    // D:\\antlr\\ConditionExpr.g:182:36: ( '0' .. '7' )
                    // D:\\antlr\\ConditionExpr.g:182:37: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }


                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:183:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 
                    // D:\\antlr\\ConditionExpr.g:183:14: ( '0' .. '7' )
                    // D:\\antlr\\ConditionExpr.g:183:15: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }

                    // D:\\antlr\\ConditionExpr.g:183:25: ( '0' .. '7' )
                    // D:\\antlr\\ConditionExpr.g:183:26: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }


                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:184:9: '\\\\' ( '0' .. '7' )
                    {
                    match('\\'); 
                    // D:\\antlr\\ConditionExpr.g:184:14: ( '0' .. '7' )
                    // D:\\antlr\\ConditionExpr.g:184:15: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }


                    }
                    break;

            }
        }
        finally {
        }
    }
    // $ANTLR end "OctalEscape"

    // $ANTLR start "BooleanLiteral"
    public final void mBooleanLiteral() throws RecognitionException {
        try {
            int _type = BooleanLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:187:16: ( 'true' | 'false' )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0=='t') ) {
                alt3=1;
            }
            else if ( (LA3_0=='f') ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:187:20: 'true'
                    {
                    match("true"); 


                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:187:27: 'false'
                    {
                    match("false"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BooleanLiteral"

    // $ANTLR start "StringLiteral"
    public final void mStringLiteral() throws RecognitionException {
        try {
            int _type = StringLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:190:5: ( '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' )
            // D:\\antlr\\ConditionExpr.g:190:8: '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"'
            {
            match('\"'); 
            // D:\\antlr\\ConditionExpr.g:190:12: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )*
            loop4:
            do {
                int alt4=3;
                int LA4_0 = input.LA(1);

                if ( (LA4_0=='\\') ) {
                    alt4=1;
                }
                else if ( ((LA4_0>='\u0000' && LA4_0<='!')||(LA4_0>='#' && LA4_0<='[')||(LA4_0>=']' && LA4_0<='\uFFFF')) ) {
                    alt4=2;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\antlr\\ConditionExpr.g:190:14: EscapeSequence
            	    {
            	    mEscapeSequence(); 

            	    }
            	    break;
            	case 2 :
            	    // D:\\antlr\\ConditionExpr.g:190:31: ~ ( '\\\\' | '\"' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "StringLiteral"

    // $ANTLR start "NumberLiteral"
    public final void mNumberLiteral() throws RecognitionException {
        try {
            int _type = NumberLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:192:16: ( '0.' ( '0' .. '9' )* | '1' .. '9' ( '0' .. '9' )* | '1' .. '9' ( '0' .. '9' )* '.' ( '0' .. '9' )* )
            int alt9=3;
            alt9 = dfa9.predict(input);
            switch (alt9) {
                case 1 :
                    // D:\\antlr\\ConditionExpr.g:192:20: '0.' ( '0' .. '9' )*
                    {
                    match("0."); 

                    // D:\\antlr\\ConditionExpr.g:192:24: ( '0' .. '9' )*
                    loop5:
                    do {
                        int alt5=2;
                        int LA5_0 = input.LA(1);

                        if ( ((LA5_0>='0' && LA5_0<='9')) ) {
                            alt5=1;
                        }


                        switch (alt5) {
                    	case 1 :
                    	    // D:\\antlr\\ConditionExpr.g:192:24: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // D:\\antlr\\ConditionExpr.g:192:34: '1' .. '9' ( '0' .. '9' )*
                    {
                    matchRange('1','9'); 
                    // D:\\antlr\\ConditionExpr.g:192:42: ( '0' .. '9' )*
                    loop6:
                    do {
                        int alt6=2;
                        int LA6_0 = input.LA(1);

                        if ( ((LA6_0>='0' && LA6_0<='9')) ) {
                            alt6=1;
                        }


                        switch (alt6) {
                    	case 1 :
                    	    // D:\\antlr\\ConditionExpr.g:192:42: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop6;
                        }
                    } while (true);


                    }
                    break;
                case 3 :
                    // D:\\antlr\\ConditionExpr.g:192:52: '1' .. '9' ( '0' .. '9' )* '.' ( '0' .. '9' )*
                    {
                    matchRange('1','9'); 
                    // D:\\antlr\\ConditionExpr.g:192:60: ( '0' .. '9' )*
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0>='0' && LA7_0<='9')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // D:\\antlr\\ConditionExpr.g:192:60: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop7;
                        }
                    } while (true);

                    match('.'); 
                    // D:\\antlr\\ConditionExpr.g:192:72: ( '0' .. '9' )*
                    loop8:
                    do {
                        int alt8=2;
                        int LA8_0 = input.LA(1);

                        if ( ((LA8_0>='0' && LA8_0<='9')) ) {
                            alt8=1;
                        }


                        switch (alt8) {
                    	case 1 :
                    	    // D:\\antlr\\ConditionExpr.g:192:72: '0' .. '9'
                    	    {
                    	    matchRange('0','9'); 

                    	    }
                    	    break;

                    	default :
                    	    break loop8;
                        }
                    } while (true);


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NumberLiteral"

    // $ANTLR start "NumberListLiteral"
    public final void mNumberListLiteral() throws RecognitionException {
        try {
            int _type = NumberListLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:193:20: ( '[' ( '0' .. '9' )+ ( ',' | ( '0' .. '9' )+ )* ']' )
            // D:\\antlr\\ConditionExpr.g:193:22: '[' ( '0' .. '9' )+ ( ',' | ( '0' .. '9' )+ )* ']'
            {
            match('['); 
            // D:\\antlr\\ConditionExpr.g:193:25: ( '0' .. '9' )+
            int cnt10=0;
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0>='0' && LA10_0<='9')) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // D:\\antlr\\ConditionExpr.g:193:25: '0' .. '9'
            	    {
            	    matchRange('0','9'); 

            	    }
            	    break;

            	default :
            	    if ( cnt10 >= 1 ) break loop10;
                        EarlyExitException eee =
                            new EarlyExitException(10, input);
                        throw eee;
                }
                cnt10++;
            } while (true);

            // D:\\antlr\\ConditionExpr.g:193:34: ( ',' | ( '0' .. '9' )+ )*
            loop12:
            do {
                int alt12=3;
                int LA12_0 = input.LA(1);

                if ( (LA12_0==',') ) {
                    alt12=1;
                }
                else if ( ((LA12_0>='0' && LA12_0<='9')) ) {
                    alt12=2;
                }


                switch (alt12) {
            	case 1 :
            	    // D:\\antlr\\ConditionExpr.g:193:35: ','
            	    {
            	    match(','); 

            	    }
            	    break;
            	case 2 :
            	    // D:\\antlr\\ConditionExpr.g:193:39: ( '0' .. '9' )+
            	    {
            	    // D:\\antlr\\ConditionExpr.g:193:39: ( '0' .. '9' )+
            	    int cnt11=0;
            	    loop11:
            	    do {
            	        int alt11=2;
            	        int LA11_0 = input.LA(1);

            	        if ( ((LA11_0>='0' && LA11_0<='9')) ) {
            	            alt11=1;
            	        }


            	        switch (alt11) {
            	    	case 1 :
            	    	    // D:\\antlr\\ConditionExpr.g:193:39: '0' .. '9'
            	    	    {
            	    	    matchRange('0','9'); 

            	    	    }
            	    	    break;

            	    	default :
            	    	    if ( cnt11 >= 1 ) break loop11;
            	                EarlyExitException eee =
            	                    new EarlyExitException(11, input);
            	                throw eee;
            	        }
            	        cnt11++;
            	    } while (true);


            	    }
            	    break;

            	default :
            	    break loop12;
                }
            } while (true);

            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NumberListLiteral"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\ConditionExpr.g:194:7: ( ( ' ' | '\\t' )+ )
            // D:\\antlr\\ConditionExpr.g:194:11: ( ' ' | '\\t' )+
            {
            // D:\\antlr\\ConditionExpr.g:194:11: ( ' ' | '\\t' )+
            int cnt13=0;
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0=='\t'||LA13_0==' ') ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // D:\\antlr\\ConditionExpr.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt13 >= 1 ) break loop13;
                        EarlyExitException eee =
                            new EarlyExitException(13, input);
                        throw eee;
                }
                cnt13++;
            } while (true);

            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    public void mTokens() throws RecognitionException {
        // D:\\antlr\\ConditionExpr.g:1:8: ( AND | OR | AND_1 | OR_1 | AND_2 | OR_2 | EQ | NEQ | GT | GTEQ | LT | LTEQ | LIKE | NOTLIKE | BELONGTO | T__28 | T__29 | BooleanLiteral | StringLiteral | NumberLiteral | NumberListLiteral | WS )
        int alt14=22;
        alt14 = dfa14.predict(input);
        switch (alt14) {
            case 1 :
                // D:\\antlr\\ConditionExpr.g:1:10: AND
                {
                mAND(); 

                }
                break;
            case 2 :
                // D:\\antlr\\ConditionExpr.g:1:14: OR
                {
                mOR(); 

                }
                break;
            case 3 :
                // D:\\antlr\\ConditionExpr.g:1:17: AND_1
                {
                mAND_1(); 

                }
                break;
            case 4 :
                // D:\\antlr\\ConditionExpr.g:1:23: OR_1
                {
                mOR_1(); 

                }
                break;
            case 5 :
                // D:\\antlr\\ConditionExpr.g:1:28: AND_2
                {
                mAND_2(); 

                }
                break;
            case 6 :
                // D:\\antlr\\ConditionExpr.g:1:34: OR_2
                {
                mOR_2(); 

                }
                break;
            case 7 :
                // D:\\antlr\\ConditionExpr.g:1:39: EQ
                {
                mEQ(); 

                }
                break;
            case 8 :
                // D:\\antlr\\ConditionExpr.g:1:42: NEQ
                {
                mNEQ(); 

                }
                break;
            case 9 :
                // D:\\antlr\\ConditionExpr.g:1:46: GT
                {
                mGT(); 

                }
                break;
            case 10 :
                // D:\\antlr\\ConditionExpr.g:1:49: GTEQ
                {
                mGTEQ(); 

                }
                break;
            case 11 :
                // D:\\antlr\\ConditionExpr.g:1:54: LT
                {
                mLT(); 

                }
                break;
            case 12 :
                // D:\\antlr\\ConditionExpr.g:1:57: LTEQ
                {
                mLTEQ(); 

                }
                break;
            case 13 :
                // D:\\antlr\\ConditionExpr.g:1:62: LIKE
                {
                mLIKE(); 

                }
                break;
            case 14 :
                // D:\\antlr\\ConditionExpr.g:1:67: NOTLIKE
                {
                mNOTLIKE(); 

                }
                break;
            case 15 :
                // D:\\antlr\\ConditionExpr.g:1:75: BELONGTO
                {
                mBELONGTO(); 

                }
                break;
            case 16 :
                // D:\\antlr\\ConditionExpr.g:1:84: T__28
                {
                mT__28(); 

                }
                break;
            case 17 :
                // D:\\antlr\\ConditionExpr.g:1:90: T__29
                {
                mT__29(); 

                }
                break;
            case 18 :
                // D:\\antlr\\ConditionExpr.g:1:96: BooleanLiteral
                {
                mBooleanLiteral(); 

                }
                break;
            case 19 :
                // D:\\antlr\\ConditionExpr.g:1:111: StringLiteral
                {
                mStringLiteral(); 

                }
                break;
            case 20 :
                // D:\\antlr\\ConditionExpr.g:1:125: NumberLiteral
                {
                mNumberLiteral(); 

                }
                break;
            case 21 :
                // D:\\antlr\\ConditionExpr.g:1:139: NumberListLiteral
                {
                mNumberListLiteral(); 

                }
                break;
            case 22 :
                // D:\\antlr\\ConditionExpr.g:1:157: WS
                {
                mWS(); 

                }
                break;

        }

    }


    protected DFA9 dfa9 = new DFA9(this);
    protected DFA14 dfa14 = new DFA14(this);
    static final String DFA9_eotS =
        "\2\uffff\2\4\2\uffff";
    static final String DFA9_eofS =
        "\6\uffff";
    static final String DFA9_minS =
        "\1\60\1\uffff\2\56\2\uffff";
    static final String DFA9_maxS =
        "\1\71\1\uffff\2\71\2\uffff";
    static final String DFA9_acceptS =
        "\1\uffff\1\1\2\uffff\1\2\1\3";
    static final String DFA9_specialS =
        "\6\uffff}>";
    static final String[] DFA9_transitionS = {
            "\1\1\11\2",
            "",
            "\1\5\1\uffff\12\3",
            "\1\5\1\uffff\12\3",
            "",
            ""
    };

    static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
    static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
    static final char[] DFA9_min = DFA.unpackEncodedStringToUnsignedChars(DFA9_minS);
    static final char[] DFA9_max = DFA.unpackEncodedStringToUnsignedChars(DFA9_maxS);
    static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
    static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
    static final short[][] DFA9_transition;

    static {
        int numStates = DFA9_transitionS.length;
        DFA9_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA9_transition[i] = DFA.unpackEncodedString(DFA9_transitionS[i]);
        }
    }

    class DFA9 extends DFA {

        public DFA9(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 9;
            this.eot = DFA9_eot;
            this.eof = DFA9_eof;
            this.min = DFA9_min;
            this.max = DFA9_max;
            this.accept = DFA9_accept;
            this.special = DFA9_special;
            this.transition = DFA9_transition;
        }
        public String getDescription() {
            return "192:1: NumberLiteral : ( '0.' ( '0' .. '9' )* | '1' .. '9' ( '0' .. '9' )* | '1' .. '9' ( '0' .. '9' )* '.' ( '0' .. '9' )* );";
        }
    }
    static final String DFA14_eotS =
        "\10\uffff\1\26\1\30\17\uffff";
    static final String DFA14_eofS =
        "\31\uffff";
    static final String DFA14_minS =
        "\1\11\7\uffff\2\75\17\uffff";
    static final String DFA14_maxS =
        "\1\174\7\uffff\1\76\1\75\17\uffff";
    static final String DFA14_acceptS =
        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\2\uffff\1\15\1\16\1\17\1\20"+
        "\1\21\1\22\1\23\1\24\1\25\1\26\1\10\1\14\1\13\1\12\1\11";
    static final String DFA14_specialS =
        "\31\uffff}>";
    static final String[] DFA14_transitionS = {
            "\1\23\26\uffff\1\23\1\uffff\1\20\3\uffff\1\5\1\uffff\1\15\1"+
            "\16\1\3\1\4\4\uffff\12\21\2\uffff\1\10\1\7\1\11\34\uffff\1\22"+
            "\5\uffff\1\1\1\14\3\uffff\1\17\5\uffff\1\12\1\uffff\1\13\1\2"+
            "\4\uffff\1\17\7\uffff\1\6",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\25\1\24",
            "\1\27",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS);
    static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS);
    static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS);
    static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS);
    static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS);
    static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS);
    static final short[][] DFA14_transition;

    static {
        int numStates = DFA14_transitionS.length;
        DFA14_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA14_transition[i] = DFA.unpackEncodedString(DFA14_transitionS[i]);
        }
    }

    class DFA14 extends DFA {

        public DFA14(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 14;
            this.eot = DFA14_eot;
            this.eof = DFA14_eof;
            this.min = DFA14_min;
            this.max = DFA14_max;
            this.accept = DFA14_accept;
            this.special = DFA14_special;
            this.transition = DFA14_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( AND | OR | AND_1 | OR_1 | AND_2 | OR_2 | EQ | NEQ | GT | GTEQ | LT | LTEQ | LIKE | NOTLIKE | BELONGTO | T__28 | T__29 | BooleanLiteral | StringLiteral | NumberLiteral | NumberListLiteral | WS );";
        }
    }
 

}